﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;

namespace SGT_ON
{
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class ONMotivo
    {
        
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class ONMotivo
    {
        #region Atributos
        protected int _id;
        protected string _descripcion;
        
        //Objetos asociados
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public string Descripcion
        {
            get
            {
                return _descripcion;
            }
            set
            {
                _descripcion = value;
            }
        }
        
        //Objetos asociados

        //Propiedades derivadas
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static MotivoTableAdapter _motivoAD;
        protected static MotivoTableAdapter Adaptador
        {
            get
            {
                if (_motivoAD == null)
                    _motivoAD = new MotivoTableAdapter();

                return _motivoAD;
            }
        }
        protected static ONMotivo ObtenerPorID(int pID)
        {   
            _STG_DAL.MotivoDataTable _dt;

            _dt = Adaptador.ObtenerPorId(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.MotivoRow)_dt.Rows[0]);

            return null;
        }
        protected static ONMotivo AsignarRowAObjeto(_STG_DAL.MotivoRow pRow)
        {
            ONMotivo _motivo = new ONMotivo();
            if (pRow != null)
            {
                _motivo = new ONMotivo();
                _motivo.ID = pRow.ID;
                _motivo.Descripcion = pRow.Descripcion;
            }
            return _motivo;
        }
        protected ONMotivo InsertarDAL(string pDescripcion)
        {
            if ((pDescripcion == null)
                || (pDescripcion == "") )
                throw new ArgumentException("Debe ingresar una descripción.");

            ID = int.Parse(Adaptador.Insertar(pDescripcion).ToString());
            return this;
        }
        protected bool ActualizarDAL(string pDescripcion, int pId)
        {
            if ((pDescripcion == null) 
                ||(pDescripcion == "") )
                throw new ArgumentException("Debe ingresar una descripción.");

            if (0 < Adaptador.Actualizar(pDescripcion, pId))
                return true;
            else
                return false;
        }
        public void EliminarDAL(int pId)
        {
            Adaptador.Eliminar(pId);
        }
        protected static ONMotivoColeccion AsignarMotivoTableAdapterAMotivoColeccion(_STG_DAL.MotivoDataTable pDataTable)
        {
            ONMotivoColeccion _motivos = new ONMotivoColeccion();
            ONMotivo _motivo;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.MotivoRow _row in pDataTable.Rows)
                {
                    _motivo = AsignarRowAObjeto(_row);
                    if (_motivo != null)
                        _motivos.Add(_motivo);
                }
            }
            return _motivos;
        }
        public static ONMotivoColeccion ObtenerTodosLosMotivosDAL()
        {
            return AsignarMotivoTableAdapterAMotivoColeccion(Adaptador.ObtenerTodosLosMotivos());
        }

        #endregion

        #region Métodos
        public ONMotivo()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            Descripcion = null;
        }

        public static ONMotivo CrearMotivo()
        {
            ONMotivo _motivo = new ONMotivo();
            return _motivo;
        }
        public static ONMotivo CrearMotivo(int pID)
        {
            ONMotivo _motivo = ObtenerPorID(pID);
            return _motivo;
        }
        public ONMotivo Insertar()
        {
            return InsertarDAL(Descripcion);
        }
        public bool Actualizar()
        {
            return ActualizarDAL(Descripcion, ID);
        }
        #endregion

        #region Metodos para datasource
        public void Actualizar(ONMotivo pMotivo)
        {
            if (pMotivo != null)
                pMotivo.Actualizar();
        }
        public ONMotivo Insertar(ONMotivo pMotivo)
        {
            if (pMotivo != null)
                return pMotivo.Insertar();
            return null;
        }
        public void Eliminar(ONMotivo pMotivo)
        {
            pMotivo.EliminarDAL(pMotivo.ID);
        }
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class ONMotivoColeccion : System.Collections.CollectionBase
    {
        public void Add(ONMotivo pMotivo)
        {
            this.List.Add(pMotivo);
        }
        public void AddUnico(ONMotivo pMotivo)
        {
            foreach (ONMotivo _motivo in this)
                if (pMotivo.ID == _motivo.ID)
                    return;
            this.List.Add(pMotivo);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(ONMotivo pMotivo)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pMotivo.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public ONMotivo this[int index]
        {
            get { return ((ONMotivo)(this.List[index])); }
            set { this.List[index] = value; }
        }
        public void ActualizarMotivos(ONMotivoColeccion pMotivos)
        {
            foreach (ONMotivo _motivo in pMotivos)
            {
                _motivo.Actualizar();
            }
        }
        public void ActualizarMotivo(ONMotivo pMotivo)
        {
            pMotivo.Actualizar();
        }

        #region Metodos de colección
        
        #endregion
        #region Para datasource
        #endregion
    }
}
